package com.mixsmart.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.Locale;
import java.util.SimpleTimeZone;

/**
 * 日期工具类
 * @author lmq
 * @version 1.0
 * 2015年8月22日
 */
public class DateUtils {

	private static final Logger logger = LoggerFactory.getLogger(DateUtils.class);

	/**
	 * 时间转为日期格式
	 * <p>如：formatter参数为空时，默认格式为“yyyy-MM-dd HH:mm:ss”</p>
	 * @param date 日期对象
	 * @param formatter 日期格式
	 * @return 日期转换后的字符串 
	 */
	public static String dateToStr(Date date, String formatter) {
		String value = null;
		if(null != date) {
			if(StringUtils.isEmpty(formatter)) {
				formatter = "yyyy-MM-dd HH:mm:ss";
			}
			SimpleDateFormat dateFormat = new SimpleDateFormat(formatter);
			value = dateFormat.format(date);
		}
		return value;
	}

	/**
	 * 时间转为日期格式
	 * <p>如：formatter参数为空时，默认格式为“yyyy-MM-dd HH:mm:ss”</p>
	 * @param date LocalDateTime日期对象
	 * @param formatterStr 日期格式
	 * @return 日期转换后的字符串
	 */
	public static String dateToStr(LocalDateTime date,String formatterStr) {
		String value = null;
		if(null != date) {
			if(StringUtils.isEmpty(formatterStr)) {
				formatterStr = "yyyy-MM-dd HH:mm:ss";
			}
			DateTimeFormatter formatter = DateTimeFormatter.ofPattern(formatterStr);
			value = formatter.format(date);
		}
		return value;
	}
	
	/**
     * 日期转为日期时间字符串格式
     * @param date 日期对象
     * @return 日期转换后的字符串 
     */
    public static String dateTimeToStr(Date date) {
        return dateToStr(date, "yyyy-MM-dd HH:mm:ss");
    }

	/**
	 * 日期转为日期时间字符串格式
	 * @param date 日期对象
	 * @return 日期转换后的字符串
	 */
	public static String dateTimeToStr(LocalDateTime date) {
		return dateToStr(date, "yyyy-MM-dd HH:mm:ss");
	}
    
    /**
     * 日期转为日期字符串格式
     * @param date 日期对象
     * @return 返回日期字符串 
     */
    public static String dateToStr(Date date) {
        return dateToStr(date, "yyyy-MM-dd");
    }

	/**
	 * 日期转为日期字符串格式
	 * @param date 日期对象
	 * @return 返回日期字符串
	 */
	public static String dateToStr(LocalDateTime date) {
		return dateToStr(date, "yyyy-MM-dd");
	}
	
	/**
	 * 解析成日期时间
	 * @param dateTimeStr 日期时间字符串；格式为“yyyy-MM-dd HH:mm:ss”
	 * @return 返回 {@link Date} 对象
	 */
	public static Date parseDateTime(String dateTimeStr) {
	    if(StringUtils.isEmpty(dateTimeStr)) {
	        return null;
	    }
        if(dateTimeStr.contains(".")) {
            dateTimeStr = dateTimeStr.substring(0, dateTimeStr.indexOf("."));
        }
	    Date datetime = null;
	    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	    try {
            datetime = dateFormat.parse(dateTimeStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
	    return datetime;
	}

	/**
	 * 解析成日期时间
	 * @param dateTimeStr 日期时间字符串；格式为“yyyy-MM-dd HH:mm:ss”
	 * @return 返回 {@link LocalDateTime} 对象
	 */
	public static LocalDateTime parseLocalDateTime(String dateTimeStr) {
		if(StringUtils.isEmpty(dateTimeStr)) {
			return null;
		}
        if(dateTimeStr.contains(".")) {
            dateTimeStr = dateTimeStr.substring(0, dateTimeStr.indexOf("."));
        }
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        return LocalDateTime.parse(dateTimeStr, formatter);
	}
	
	/**
     * 解析成日期
     * @param dateStr 日期字符串；格式为“yyyy-MM-dd”
     * @return 返回 {@link Date} 对象
     */
    public static Date parseDate(String dateStr) {
        return parseDate(dateStr, null);
    }

	/**
	 * 解析成日期
	 * @param dateStr 日期字符串；
	 * @param formatter  格式；默认为“yyyy-MM-dd”
	 * @return 返回 {@link Date} 对象
	 */
	public static Date parseDate(String dateStr, String formatter) {
		if(StringUtils.isEmpty(dateStr)) {
			return null;
		}
		if(StringUtils.isEmpty(formatter)) {
			formatter = "yyyy-MM-dd";
		}
        if(dateStr.contains(".")) {
            dateStr = dateStr.substring(0, dateStr.indexOf("."));
        }
		Date date = null;
		SimpleDateFormat dateFormat = new SimpleDateFormat(formatter);
		try {
			date = dateFormat.parse(dateStr);
		} catch (ParseException e) {
			LoggerUtils.error(logger, e);
		}
		return date;
	}

	/**
	 * 解析成日期
	 * @param dateStr 日期字符串；
	 * @param formatterStr  格式；默认为“yyyy-MM-dd”
	 * @return 返回 {@link LocalDate} 对象
	 */
	public static LocalDate parseLocalDate(String dateStr, String formatterStr) {
		if(StringUtils.isEmpty(dateStr)) {
			return null;
		}
		if(StringUtils.isEmpty(formatterStr)) {
			formatterStr = "yyyy-MM-dd";
		}
        if(dateStr.contains(".")) {
            dateStr = dateStr.substring(0, dateStr.indexOf("."));
        }
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern(formatterStr);
        return LocalDate.parse(dateStr, formatter);
	}
    
    /**
     * 获取当前日期的字符串形式
     * @param formatter 日期格式；如果为空，则使用默认格式：“yyyy-MM-dd HH:mm:ss”
     * @return 返回当前日期格式化后的日期字符串
     */
    public static String getCurrentDateStr(String formatter) {
        if(StringUtils.isEmpty(formatter)) {
            formatter = "yyyy-MM-dd HH:mm:ss";
        }
        return DateUtils.dateToStr(new Date(), formatter);
    }

	/**
	 * 获取当前日期的字符串形式
	 * @return 返回当前日期格式化后的日期字符串
	 */
	public static String getCurrentDateStr() {
		String formatter = "yyyy-MM-dd HH:mm:ss";
		return getCurrentDateStr(formatter);
	}

	/**
	 * 解析日期；使用java8新增的日期类
	 * @param dateTimeStr 字符串日期
	 * @param format 日期格式；默认值为:"yyyy-MM-dd HH:mm:ss"
	 * @return 返回Date日期类型的对象;如dateTimeStr为空，则返回null
	 */
	public static Date parseDateTime(String dateTimeStr, String format) {
		if(StringUtils.isEmpty(dateTimeStr)) {
			return null;
		}
		if(StringUtils.isEmpty(format)) {
			format = "yyyy-MM-dd HH:mm:ss";
		}
        if(dateTimeStr.contains(".")) {
            dateTimeStr = dateTimeStr.substring(0, dateTimeStr.indexOf("."));
        }
		/*DateTimeFormatter df = DateTimeFormatter.ofPattern(format);
		LocalDateTime dateTime = LocalDateTime.parse(dateTimeStr, df);
		return Date.from(dateTime.atZone(ZoneId.systemDefault()).toInstant());*/
		SimpleDateFormat dateFormat = new SimpleDateFormat(format);
		Date date = null;
		try {
			date = dateFormat.parse(dateTimeStr);
		} catch (Exception ex) {
			LoggerUtils.error(logger, ex);
		}
		return date;
	}

	/**
	 * 解析日期
	 * @param dateTimeStr 字符串日期
	 * @param formatStr 日期格式；默认值为:"yyyy-MM-dd HH:mm:ss"
	 * @return 返回Date日期类型的对象;如dateTimeStr为空，则返回null
	 */
	public static LocalDateTime parseLocalDateTime(String dateTimeStr, String formatStr) {
		if(StringUtils.isEmpty(dateTimeStr)) {
			return null;
		}
		if(StringUtils.isEmpty(formatStr)) {
			formatStr = "yyyy-MM-dd HH:mm:ss";
		}
        if(dateTimeStr.contains(".")) {
            dateTimeStr = dateTimeStr.substring(0, dateTimeStr.indexOf("."));
        }
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern(formatStr);
        return LocalDateTime.parse(dateTimeStr, formatter);
	}

	/**
	 * 时间戳转化为字符串日期；
	 * @param time 时间戳
	 * @param format 日期格式
	 * @return 返回字符串格式的日期
	 */
	public static String convert(Long time, String format) {
		if(null == time) {
			return "";
		}
		if(time <= 0) {
			return "";
		}
		Date date = new Date(time);
		if(StringUtils.isEmpty(format)) {
			return dateTimeToStr(date);
		} else {
			return dateToStr(date, format);
		}
	}

	/**
	 * 时间戳转化为字符串日期；
	 * @param timeStr 时间戳字符串
	 * @param format 日期格式
	 * @return 返回字符串格式的日期
	 */
	public static String convert(String timeStr, String format) {
		if(StringUtils.isEmpty(timeStr) || !StringUtils.isInteger(timeStr)) {
			return "";
		}
		return convert(Long.parseLong(timeStr), format);
	}

	/**
	 * 时间戳转化为字符串日期；
	 * @param timeStr 时间戳字符串
	 * @return 返回字符串格式的日期
	 */
	public static String convert(String timeStr) {
		return convert(timeStr, null);
	}

	/**
	 * 时间戳转化为字符串日期；返回的日期格式为：yyyy-MM-dd HH:mm:ss
	 * @param time 时间戳
	 * @return 返回字符串格式的日期
	 */
	public static String convert(Long time) {
		if(null == time) {
			return "";
		}
		if(time <= 0) {
			return "";
		}
		return dateTimeToStr(new Date(time));
	}

	/**
	 * Get a UTC format string by current date, e.g. 'Thu, 06 Feb 2020 07:32:54 GMT'
	 *
	 * @return the UTC format string
	 */
	public static String getDateUTCString() {
		SimpleDateFormat df = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
		df.setTimeZone(new SimpleTimeZone(0, "GMT"));
		return df.format(new Date());
	}

	/**
	 * 时间戳转换为日期对象
	 * @param time 时间戳
	 * @return 返回日期对象
	 */
	public static Date convertDate(Long time) {
		if(null == time) {
			return null;
		}
		return new Date(time);
	}

	/**
	 * 时间戳转换为日期对象
	 * @param timeStr 时间戳字符串
	 * @return 返回日期对象
	 */
	public static Date convertDate(String timeStr) {
		if(StringUtils.isEmpty(timeStr) || !StringUtils.isInteger(timeStr)) {
			return null;
		}
		return convertDate(Long.parseLong(timeStr));
	}

	/**
	 * 日期对象转换为时间戳
	 * @param date 日期对象
	 * @return 返回时间戳
	 */
	public static long convertTime(Date date) {
		if(null != date) {
			return date.getTime();
		}
		return 0L;
	}

	/**
	 * 日期对象转换为时间戳
	 * @param date 日期对象
	 * @return 返回时间戳
	 */
	public static long convertTime(LocalDateTime date) {
		if(null != date) {
			return date.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
		}
		return 0L;
	}
}
